// 格式化时间 - 返回格式：月/日 时:分
export const formatTime = (date = new Date()) => {
  if (typeof date === 'string') {
    date = new Date(date);
  }
  const month = (date.getMonth() + 1).toString().padStart(2, '0');
  const day = date.getDate().toString().padStart(2, '0');
  const hours = date.getHours().toString().padStart(2, '0');
  const minutes = date.getMinutes().toString().padStart(2, '0');
  return `${month}/${day} ${hours}:${minutes}`;
};

// 仅格式化时间（时:分）
export const formatTimeOnly = (date = new Date()) => {
  if (typeof date === 'string') {
    date = new Date(date);
  }
  const hours = date.getHours().toString().padStart(2, '0');
  const minutes = date.getMinutes().toString().padStart(2, '0');
  return `${hours}:${minutes}`;
};

// 生成唯一ID
export const generateId = () => {
  return Date.now().toString(36) + Math.random().toString(36).substr(2);
};

// 本地存储管理
export const storage = {
  set: (key, value) => {
    try {
      localStorage.setItem(key, JSON.stringify(value));
      return true;
    } catch (error) {
      console.error('设置本地存储失败:', error);
      return false;
    }
  },
  get: (key, defaultValue = null) => {
    try {
      const value = localStorage.getItem(key);
      return value ? JSON.parse(value) : defaultValue;
    } catch (error) {
      console.error('获取本地存储失败:', error);
      return defaultValue;
    }
  },
  remove: (key) => {
    try {
      localStorage.removeItem(key);
      return true;
    } catch (error) {
      console.error('删除本地存储失败:', error);
      return false;
    }
  }
};

// 会话ID管理：为每个角色生成并保持唯一 chatId
export const chatSession = {
  // 为指定角色获取已有chatId；不存在则返回null
  get(roleId) {
    const key = `chat_session_${roleId}`;
    return storage.get(key, null);
  },
  // 生成新的唯一chatId（字符串），并持久化到localStorage
  // 采用时间戳 + 随机段，避免冲突；作为字符串传输即可（后端接收String）
  create(roleId) {
    // 13位毫秒时间戳 + 5位随机数，长度18，避免溢出展示为字符串
    const base = Date.now().toString();
    const rand = Math.floor(Math.random() * 100000).toString().padStart(5, '0');
    const chatId = `${base}${rand}`;
    const key = `chat_session_${roleId}`;
    storage.set(key, chatId);
    return chatId;
  },
  // 获取或创建：保持同一角色会话ID一致性
  ensure(roleId) {
    let id = this.get(roleId);
    if (!id) id = this.create(roleId);
    return id;
  },
  // 重置指定角色的chatId（用于开始新会话）
  reset(roleId) {
    const key = `chat_session_${roleId}`;
    storage.remove(key);
  }
};

// 音频处理工具
export const audioUtils = {
  // 播放音频文件
  playAudio: (audioBlob) => {
    const audioUrl = URL.createObjectURL(audioBlob);
    const audio = new Audio(audioUrl);
    
    audio.play().catch(error => {
      console.error('播放音频失败:', error);
    });
    
    // 清理URL对象
    audio.onended = () => {
      URL.revokeObjectURL(audioUrl);
    };
    
    return audio;
  },
  
  // 停止播放
  stopAudio: (audioElement) => {
    if (audioElement && !audioElement.paused) {
      audioElement.pause();
      audioElement.currentTime = 0;
    }
  },
  
  // 文字转语音（使用浏览器Web Speech API）
  textToSpeech: (text, voiceStyle = 'default') => {
    // 检查浏览器是否支持Web Speech API
    if (!('speechSynthesis' in window)) {
      console.warn('您的浏览器不支持文字转语音功能');
      return null;
    }
    
    const utterance = new SpeechSynthesisUtterance(text);
    
    // 根据角色设置不同的语音参数
    switch (voiceStyle) {
      case 'young':
        // 年轻声音参数
        utterance.pitch = 1.2;
        utterance.rate = 1.1;
        break;
      case 'wise':
        // 智慧声音参数
        utterance.pitch = 0.8;
        utterance.rate = 0.9;
        break;
      case 'poetic':
        // 诗意声音参数
        utterance.pitch = 1.1;
        utterance.rate = 0.8;
        break;
      case 'knowledgeable':
        // 知识渊博声音参数
        utterance.pitch = 0.9;
        utterance.rate = 1.0;
        break;
      default:
        // 默认参数
        utterance.pitch = 1.0;
        utterance.rate = 1.0;
    }
    
    // 开始语音合成
    window.speechSynthesis.speak(utterance);
    
    return utterance;
  }
};

// 将HSV颜色转换为十六进制
const hsvToHex = (h, s, v) => {
  let r, g, b;
  const i = Math.floor(h * 6);
  const f = h * 6 - i;
  const p = v * (1 - s);
  const q = v * (1 - f * s);
  const t = v * (1 - (1 - f) * s);

  switch (i % 6) {
    case 0: r = v; g = t; b = p; break;
    case 1: r = q; g = v; b = p; break;
    case 2: r = p; g = v; b = t; break;
    case 3: r = p; g = q; b = v; break;
    case 4: r = t; g = p; b = v; break;
    case 5: r = v; g = p; b = q; break;
  }

  const toHex = (c) => {
    const hex = Math.round(c * 255).toString(16);
    return hex.length === 1 ? '0' + hex : hex;
  };

  return '#' + toHex(r) + toHex(g) + toHex(b);
};

// 生成随机颜色（使用HSV颜色空间）
const generateRandomColor = () => {
  // 随机色相（0-360度映射到0-1）
  const hue = Math.random();
  // 固定饱和度（80-100%），确保颜色鲜艳
  const saturation = 0.8 + Math.random() * 0.2;
  // 固定亮度（60-80%），确保文本可读性
  const value = 0.6 + Math.random() * 0.2;
  
  return hsvToHex(hue, saturation, value);
};

// 基于文本生成颜色
export const generateColorFromText = (text) => {
  // 直接返回随机颜色
  return generateRandomColor();
};

// 计算文本颜色（根据背景色的亮度返回黑色或白色）
export const calculateTextColor = (bgColor) => {
  // 提取RGB值
  const hex = bgColor.replace('#', '');
  const r = parseInt(hex.substr(0, 2), 16);
  const g = parseInt(hex.substr(2, 2), 16);
  const b = parseInt(hex.substr(4, 2), 16);
  
  // 计算亮度（使用WCAG标准的亮度公式）
  const brightness = (r * 299 + g * 587 + b * 114) / 1000;
  
  // 亮度大于128返回黑色，否则返回白色
  return brightness > 128 ? '#000000' : '#ffffff';
};

// 主题管理
// 提供主题切换功能，支持亮色和暗色主题
export const themeManager = {
  // 当前主题
  currentTheme: 'light',
  
  // 初始化主题
  init() {
    // 从localStorage获取上次使用的主题
    const savedTheme = storage.get('appTheme');
    if (savedTheme) {
      this.switchTheme(savedTheme);
    } else {
      // 检测系统主题偏好
      const prefersDark = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;
      this.switchTheme(prefersDark ? 'dark' : 'light');
    }
  },
  
  // 切换主题
  switchTheme(theme) {
    if (!['light', 'dark'].includes(theme)) {
      return;
    }
    
    this.currentTheme = theme;
    
    // 保存主题到localStorage
    storage.set('appTheme', theme);
    
    // 更新data-theme属性
    const html = document.documentElement;
    html.setAttribute('data-theme', theme);
    
    // 更新body类名，保留原有类名
    document.body.classList.toggle('light-mode', theme === 'light');
    document.body.classList.toggle('dark-mode', theme === 'dark');
    
    // 触发主题变化事件
    window.dispatchEvent(new CustomEvent('themeChanged', { detail: { theme } }));
  },
  
  // 切换到亮色主题
  switchToLight() {
    this.switchTheme('light');
  },
  
  // 切换到暗色主题
  switchToDark() {
    this.switchTheme('dark');
  },
  
  // 切换明暗主题
  toggleTheme() {
    this.switchTheme(this.currentTheme === 'light' ? 'dark' : 'light');
  },
  
  // 获取当前主题
  getCurrentTheme() {
    return this.currentTheme;
  },
  
  // 判断是否为暗色主题
  isDarkMode() {
    return this.currentTheme === 'dark';
  }
};

// 消息导出工具
export const messageExporter = {
  // 导出消息为文本格式
  exportAsText(messages, roleName) {
    const timestamp = new Date().toLocaleString('zh-CN');
    let content = `===== 与${roleName}的对话记录 =====\n`;
    content += `导出时间: ${timestamp}\n\n`;
    
    messages.forEach(msg => {
      const sender = msg.isUser ? '我' : roleName;
      content += `${sender} (${msg.time}):\n`;
      content += `${msg.content}\n\n`;
    });
    
    return content;
  },
  
  // 下载文本文件
  downloadTextFile(content, filename) {
    const blob = new Blob([content], { type: 'text/plain;charset=utf-8' });
    const link = document.createElement('a');
    const url = URL.createObjectURL(blob);
    
    link.href = url;
    link.download = filename;
    
    document.body.appendChild(link);
    link.click();
    
    // 清理
    setTimeout(() => {
      document.body.removeChild(link);
      URL.revokeObjectURL(url);
    }, 0);
  },
  
  // 导出消息并下载
  exportAndDownload(messages, roleName) {
    const content = this.exportAsText(messages, roleName);
    const filename = `对话记录_${roleName}_${Date.now()}.txt`;
    this.downloadTextFile(content, filename);
  }
};